package com.tbynet.jwp.framework.core;

import com.jfinal.log.Log;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Jwp框架线程池管理类
 * 职责：统一创建、管理、关闭自定义线程池
 */
public class JwpExecutor {
    // 日志实例
    private static final Log log = Log.getLog(JwpExecutor.class);
    // 单例实例（饿汉式，线程安全）
    private static final JwpExecutor INSTANCE = new JwpExecutor();
    // 自定义线程池实例
    private final ExecutorService executorService;

    /**
     * 私有构造器：初始化线程池
     * 采用CPU核心数动态配置线程池参数，适配不同服务器
     */
    private JwpExecutor() {
        int corePoolSize = Runtime.getRuntime().availableProcessors(); // 核心线程数=CPU核心数
        int maximumPoolSize = corePoolSize * 2; // 最大线程数=核心线程数*2
        int queueCapacity = 1024; // 任务队列容量

        // 初始化线程池
        this.executorService = new ThreadPoolExecutor(
                corePoolSize,
                maximumPoolSize,
                60L, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(queueCapacity),
                // 自定义线程工厂，给线程命名便于排查问题
                r -> {
                    AtomicInteger threadNum = new AtomicInteger(1);
                    return new Thread(r, "jwp-executor-thread-" + threadNum.getAndIncrement());
                },
                // 拒绝策略：当线程池满时，由调用线程执行任务，避免任务丢失
                new ThreadPoolExecutor.CallerRunsPolicy()
        );
        log.info("JwpExecutor线程池初始化完成，核心线程数：{}，最大线程数：{}", corePoolSize, maximumPoolSize);
    }

    /**
     * 获取单例实例
     */
    public static JwpExecutor getInstance() {
        return INSTANCE;
    }

    /**
     * 获取线程池实例
     */
    public ExecutorService getExecutorService() {
        return executorService;
    }

    /**
     * 关闭线程池（优雅关闭）
     * 1. 先拒绝新任务，等待已提交任务执行完成
     * 2. 超时后强制关闭，避免应用卡死
     */
    public void shutdown() {
        if (executorService == null || executorService.isShutdown()) {
            log.warn("JwpExecutor线程池已关闭，无需重复操作");
            return;
        }

        try {
            // 第一步：优雅关闭，拒绝新任务，等待现有任务执行
            executorService.shutdown();
            log.info("JwpExecutor线程池开始优雅关闭，等待剩余任务执行...");

            // 等待5秒，判断线程池是否关闭完成
            if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
                log.warn("JwpExecutor线程池优雅关闭超时，开始强制关闭...");
                // 第二步：超时后强制关闭，中断正在执行的任务
                executorService.shutdownNow();
                // 再次等待1秒，确认强制关闭
                if (!executorService.awaitTermination(1, TimeUnit.SECONDS)) {
                    log.error("JwpExecutor线程池强制关闭失败，可能存在资源泄漏");
                }
            }

            log.info("JwpExecutor线程池关闭完成");
        } catch (InterruptedException e) {
            // 捕获中断异常，再次强制关闭
            Thread.currentThread().interrupt();
            executorService.shutdownNow();
            log.error("JwpExecutor线程池关闭被中断，执行强制关闭", e);
        }
    }
}
